Djinn and Tonic - Erobeats/fileio.cpp

   1 #include "FileIO.h"
   2
   3 #include "ScreenNames.h"
   4 #include "RescourceKeys.h"
   5
   6 FileIO::FileIO()
   7 {
   8         password = "Test";
   9 }
  10 FileIO::FileIO(FileIO* fio)
  11 {
  12         rsc = fio->rsc;
  13         password = "Test";
  14 }
  15 FileIO::FileIO(ResourceMaster* rscrc)
  16 {
  17         rsc = rscrc;
  18         password = "Test";
  19 }
  20
  21
  22 FileIO::~FileIO()
  23 {
  24 }
  25
  26 //old methods
  27
  28 void FileIO::storeGameText(std::vector<std::string> item) {
  29         rsc->gameText = item;
  30 }
  31 //problematic
  32 void FileIO::saveUserData(int data, int line) {
  33         std::ifstream saveFile("data/save.txt");
  34         std::ofstream tempFile("data/temp.txt");
  35
  36         std::array<std::string,3> currentData;
  37         int counter = 0;
  38         while (!saveFile.eof()) {
  39                 std::string buffer;
  40                 std::getline(saveFile, buffer);
  41                 if (buffer != "" && buffer != "\n" && buffer != " ") {
  42                         currentData.at(counter) = buffer;
  43                         std::cout << buffer << "\n";
  44                         counter++;
  45                 }
  46         }
  47
  48         counter = 0;
  49         while (counter < 3) {
  50                 if (line != counter + 1) {
  51                         tempFile << currentData.at(counter) + "\n";
  52                 }
  53                 else {
  54                         tempFile << std::to_string(data) + "\n";
  55                 }
  56                 counter++;
  57         }
  58
  59         saveFile.close();
  60         tempFile.close();
  61
  62         std::remove("data/save.txt");
  63         std::rename("data/temp.txt", "data/save.txt");
  64 }
  65
  66 void FileIO::saveScoreData(int gamemode, int data, int line) {
  67         std::ifstream saveFile("data/scores.txt");
  68         std::ofstream tempFile("data/temp.txt");
  69         std::array<std::string, 8> currentData;
  70         int counter = 0;
  71         while (!saveFile.eof()) {
  72                 std::string buffer;
  73                 std::getline(saveFile, buffer);
  74                 if (buffer != "" && buffer != "\n" && buffer != " ") {
  75                         currentData.at(counter) = buffer;
  76                         counter++;
  77                         std::cout << buffer << "\n";
  78                 }
  79         }
  80         std::cout << "skip";
  81         counter = 0;
  82         while (counter < 8) {
  83                 if (counter % 2 != gamemode - 1 || counter / 2 + 1 != line) {
  84                         tempFile << currentData.at(counter) + "\n";
  85                 }
  86                 else {
  87                         tempFile << std::to_string(data) + "\n";
  88                 }
  89                 counter++;
  90         }
  91
  92         saveFile.close();
  93         tempFile.close();
  94
  95         std::remove("data/scores.txt");
  96         std::rename("data/temp.txt", "data/scores.txt");
  97 }
  98
  99 std::vector<std::string> FileIO::loadLanguage(std::string path)
 100 {
 101         std::ifstream langData;
 102         langData.open(path);
 103
 104         std::string text;
 105         std::vector<std::string> result;
 106         while (std::getline(langData, text)) {
 107                 std::cout << text << "\n";
 108                 if (!text.empty()) {
 109                         if (text.length() == 1 && text.at(0) != ' ') {
 110                                 result.push_back(text);
 111                         }
 112                         else if (text.at(0) != '/' && text.at(1) != '/') {
 113                                 result.push_back(text);
 114                         }
 115                 }
 116         }
 117         langData.close();
 118         storeGameText(result);
 119         return result;
 120 }
 121
 122 int FileIO::loadUserData(int line) {
 123
 124         std::string storedData;
 125         std::ifstream data;
 126         data.open("Data/save.txt");
 127
 128         std::array<std::string, 3> currentData;
 129         int counter = 0;
 130         while (!data.eof()) {
 131                 std::string buffer;
 132                 std::getline(data, buffer);
 133                 if (buffer != "" && buffer != "\n" && buffer != " ") {
 134                         currentData.at(counter) = buffer;
 135                         std::cout << buffer << "\n";
 136                         counter++;
 137                 }
 138         }
 139         data.close();
 140
 141         int intStoredData;
 142         std::stringstream convert(currentData.at(line - 1));
 143         if (!(convert >> intStoredData)) {
 144                 intStoredData = -1;
 145                 std::cout << "err\n";
 146         }
 147         return intStoredData;
 148 }
 149
 150 int FileIO::loadScoreData(int gamemode, int line) {
 151         std::string storedData;
 152         std::ifstream data;
 153         data.open("Data/scores.txt");
 154         std::array<std::string, 8> currentData;
 155         int counter = 0;
 156
 157         while (!data.eof()) {
 158                 std::string buffer;
 159                 std::getline(data, buffer);
 160                 if (buffer != "" && buffer != "\n" && buffer != " ") {
 161                         currentData.at(counter) = buffer;
 162                         std::cout << buffer;
 163                         counter++;
 164                 }
 165         }
 166         std::cout << "\t";
 167
 168         data.close();
 169
 170         if (gamemode == arcade) {
 171                 line = (line - 1) * 2 + 1;
 172         }
 173         else if (gamemode == life) {
 174                 line = line * 2;
 175         }
 176
 177         int intStoredData;
 178         std::stringstream convert(currentData.at(line - 1));
 179         if (!(convert >> intStoredData)) {
 180                 intStoredData = -1;
 181                 std::cout << "err\n";
 182         }
 183         return intStoredData;
 184 }
 185
 186 /*
 187 void FileIO::loadMenuItems()
 188 {
 189         std::vector<SDL_Texture*> menuTextures;
 190
 191         for (int fileName = LangBG; fileName <= GenericBar; fileName++) {
 192                 SDL_Texture* sdlText = loadTexture("Art/" + std::to_string(fileName + 1) + ".png");
 193                 if (sdlText == NULL) {
 194                         std::cout << SDL_GetError() << " Number " << (fileName + 1) << ".png\n";
 195                 }
 196                 menuTextures.push_back(sdlText);
 197         }
 198         storeTextures(menuTextures);
 199 }
 200
 201 void FileIO::loadMenuAnimations() {
 202         std::vector<std::vector<SDL_Texture*>> menuAnimations;
 203
 204         for (int animationFolder = WhiteBlueBG; animationFolder <= WhiteBlueBG; animationFolder++) {
 205                 std::vector<SDL_Texture*> sdlTextList;
 206                 for (int i = 1; i <= 57; i++) {
 207                         sdlTextList.push_back(loadTexture("Art/" + std::to_string(animationFolder) + "/ (" + std::to_string(i) + ").png"));
 208                 }
 209                 if (sdlTextList.front() == NULL) {
 210                         std::cout << SDL_GetError();
 211                 }
 212                 menuAnimations.push_back(sdlTextList);
 213         }
 214         storeAnimations(menuAnimations);
 215 }
 216
 217
 218 void FileIO::loadGameAnimations()
 219 {
 220         std::vector< std::vector<SDL_Texture*>> gameAnimations;
 221 }
 222
 223 void FileIO::loadGameGraphics()
 224 {
 225         std::vector<SDL_Texture*> gameGraphics;
 226 }
 227
 228 SDL_Texture* FileIO::loadTexture(std::string path) {
 229
 230         SDL_Texture* newTexture = NULL;
 231         SDL_Surface* loadedSurface = IMG_Load(path.c_str());
 232
 233         newTexture = SDL_CreateTextureFromSurface(rsc->rendPtr, loadedSurface);
 234         SDL_FreeSurface(loadedSurface);
 235
 236         return newTexture;
 237 }*/
 238
 239 //new methods
 240
 241 //problematic
 242 SDL_Texture* FileIO::loadSpecificImage(std::string path, int image) {
 243         return extractSpecificTexture(path, image);
 244 }
 245 std::vector<SDL_Texture*> FileIO::loadSpecificZip(std::string path) {
 246         return extractTexturesFromZip(path);
 247 }
 248 void FileIO::loadBGZip() {
 249         rsc->gameBG = extractTexturesFromZip("BG.zip");
 250 }
 251 void FileIO::loadTexturesZip() {
 252         rsc->gameGraphics = extractTexturesFromZip("Textures.zip");
 253 }
 254 void FileIO::loadAnimationsZip() {
 255         rsc->gameAnimations.push_back(extractTexturesFromZip("(0).zip"));
 256         /**/
 257         for (int i = 1; i <= 36; i++) {
 258                 rsc->gameAnimations.push_back(extractTexturesFromZip(" (" + std::to_string(i) + ").zip"));
 259         }
 260 }
 261 void FileIO::loadAnimationsZipUntil(int number) {
 262         if (number == 0) {
 263                 rsc->gameAnimations.push_back(extractTexturesFromZip("(0).zip"));
 264         }
 265         else {
 266                 for (int i = 1; i <= number; i++) {
 267                         rsc->gameAnimations.push_back(extractTexturesFromZip(" (" + std::to_string(i) + ").zip"));
 268                 }
 269         }
 270 }
 271 void FileIO::loadAnimationsZipPast(int number) {
 272         if (number == 0) {
 273                 rsc->gameAnimations.push_back(extractTexturesFromZip("(0).zip"));
 274         }
 275         for (int i = number + 1; i <= 36; i++) {
 276                 //quick fix for file name issues
 277                 try {
 278                         rsc->gameAnimations.push_back(extractTexturesFromZip("(" + std::to_string(i) + ").zip"));
 279                 }
 280                 catch (std::exception e) {
 281                         rsc->gameAnimations.push_back(extractTexturesFromZip(" (" + std::to_string(i) + ").zip"));
 282                 }
 283         }
 284 }
 285 void FileIO::loadAnimationsZipInterval(int start, int end) {
 286         if (start == 0) {
 287                 rsc->gameAnimations.push_back(extractTexturesFromZip("(0).zip"));
 288                 start++;
 289         }
 290         for (int i = start; i <= end; i++) {
 291                 //quick fix for file name issues
 292                 try{
 293                         rsc->gameAnimations.push_back(extractTexturesFromZip("(" + std::to_string(i) + ").zip"));
 294                 }
 295                 catch (std::exception e) {
 296                         rsc->gameAnimations.push_back(extractTexturesFromZip(" (" + std::to_string(i) + ").zip"));
 297                 }
 298         }
 299 }
 300 void FileIO::loadBGMZip() {
 301         rsc->gameBGM = extractBGMZip("BGM.zip");
 302 }
 303 void FileIO::loadSFXZip() {
 304         rsc->gameSFX = extractSFXZip("SFX.zip");
 305 }
 306
 307 SDL_Texture* FileIO::extractSpecificTexture(std::string path, int image) {
 308         unzFile genericZip = unzOpen(path.c_str());
 309         unz_global_info ugi;
 310         unzGetGlobalInfo(genericZip, &ugi);
 311
 312         SDL_Texture* specificText = NULL;
 313
 314         uLong i;
 315         std::cout << "Extracting" << "\n";
 316         for (i = 0; i < ugi.number_entry; i++) {
 317                 unz_file_info ufi;
 318                 char filename[256];
 319                 unzGetCurrentFileInfo(genericZip, &ufi, filename, sizeof(filename), NULL, 0, NULL, 0);
 320                 std::string name = getZipFileName(ufi, genericZip);
 321                 if (name == std::to_string(image)) {
 322                         uInt size_buf = ufi.uncompressed_size;
 323                         void*buf = (void*)malloc(size_buf);
 324                         int err = unzOpenCurrentFilePassword(genericZip, password);
 325                         if (err != UNZ_OK) {
 326                                 printf("errPass\n");
 327                         }
 328                         err = unzReadCurrentFile(genericZip, buf, size_buf);
 329                         if (err < 0) {
 330                                 printf("ErrReadZip\n");
 331                         }
 332                         SDL_RWops* rw = SDL_RWFromMem(buf, size_buf);
 333                         if (rw == NULL) {
 334                                 printf("RW\n");
 335                         }
 336                         SDL_Surface* surf = IMG_Load_RW(rw, 1);
 337                         if (surf == NULL) {
 338                                 std::cout << "surf\n";
 339                         }
 340                         specificText = SDL_CreateTextureFromSurface(rsc->rendPtr, surf);
 341                         if (specificText == NULL) {
 342                                 std::cout << "text\n";
 343                         }
 344                         SDL_FreeSurface(surf);
 345                         free(buf);
 346                         unzClose(genericZip);
 347                         break;
 348                 }
 349                 unzGoToNextFile(genericZip);
 350         }
 351         return specificText;
 352 }
 353
 354 std::vector<Mix_Music*> FileIO::extractBGMZip(std::string path) {
 355         unzFile bgmZip = unzOpen(path.c_str());
 356         unz_global_info ugi;
 357         unzGetGlobalInfo(bgmZip, &ugi);
 358
 359         std::vector<Mix_Music*> rtnVect(ugi.number_entry);
 360         std::vector<Mix_Music*>::iterator it;
 361
 362         SDL_RWops* rw = NULL;
 363         uLong i;
 364         std::cout << "Extracting" << "\n";
 365         for (i = 0; i < ugi.number_entry; i++) {
 366                 unz_file_info ufi;
 367                 char filename[256];
 368                 unzGetCurrentFileInfo(bgmZip, &ufi, filename, sizeof(filename), NULL, 0, NULL, 0);
 369
 370                 uInt size_buf = ufi.uncompressed_size;
 371                 //std::cout << size_buf << "\n";
 372                 void* buf = (void*)malloc(size_buf);
 373                 int err = unzOpenCurrentFilePassword(bgmZip, password);
 374                 if (err != UNZ_OK)
 375                 {
 376                         printf("errPass\n");
 377                 }
 378
 379                 err = unzReadCurrentFile(bgmZip, buf, size_buf);
 380                 if (err < 0) {
 381                         std::cout << "errunzBGM\n";
 382                 }
 383                 rw = SDL_RWFromMem(buf, size_buf);
 384                 if (rw == NULL) {
 385                         std::cout << "RW\n";
 386                 }
 387
 388                 Mix_Music* temp = Mix_LoadMUS_RW(rw, 1);
 389
 390                 std::string name = getZipFileName(ufi, bgmZip);
 391                 char chars[] = "()-.wav";
 392
 393                 for (unsigned int i = 0; i < strlen(chars); ++i)
 394                 {
 395                         // you need include <algorithm> to use general algorithms like std::remove()
 396                         name.erase(std::remove(name.begin(), name.end(), chars[i]), name.end());
 397                 }
 398                 int index = stoi(name) - 1;
 399
 400                 std::cout << index << "\n";
 401
 402                 it = rtnVect.begin() + index;
 403                 rtnVect.at(index) = temp;
 404                 unzGoToNextFile(bgmZip);
 405         }
 406         unzClose(bgmZip);
 407         return rtnVect;
 408 }
 409
 410 std::vector<Mix_Chunk*> FileIO::extractSFXZip(std::string path) {
 411         unzFile sfxZip = unzOpen(path.c_str());
 412         unz_global_info ugi;
 413         unzGetGlobalInfo(sfxZip, &ugi);
 414
 415         std::vector<Mix_Chunk*> rtrnVector(ugi.number_entry);
 416
 417         SDL_RWops* rw = NULL;
 418         uLong i;
 419         std::cout << "Extracting" << "\n";
 420         for (i = 0; i < ugi.number_entry; i++) {
 421                 unz_file_info ufi;
 422                 char filename[256];
 423                 unzGetCurrentFileInfo(sfxZip, &ufi, filename, sizeof(filename), NULL, 0, NULL, 0);
 424
 425                 uInt size_buf = ufi.uncompressed_size;
 426                 //std::cout << size_buf << "\n";
 427                 void* buf = (void*)malloc(size_buf);
 428                 int err = unzOpenCurrentFilePassword(sfxZip, password);
 429                 if (err != UNZ_OK)
 430                 {
 431                         printf("errPass\n");
 432                 }
 433
 434                 err = unzReadCurrentFile(sfxZip, buf, size_buf);
 435                 if (err < 0) {
 436                         std::cout << "errunzSFX\n";
 437                 }
 438                 rw = SDL_RWFromMem(buf, size_buf);
 439                 if (rw == NULL) {
 440                         std::cout << "RW\n";
 441                 }
 442                 Mix_Chunk* temp = Mix_LoadWAV_RW(rw, 1);
 443                 std::string name = getZipFileName(ufi, sfxZip);
 444                 char chars[] = "()-.wav";
 445
 446                 for (unsigned int i = 0; i < strlen(chars); ++i)
 447                 {
 448                         // you need include <algorithm> to use general algorithms like std::remove()
 449                         name.erase(std::remove(name.begin(), name.end(), chars[i]), name.end());
 450                 }
 451                 int index = stoi(name) - 1;
 452
 453                 std::cout << index << "\n";
 454                 rtrnVector.at(index) = (temp);
 455
 456                 unzGoToNextFile(sfxZip);
 457         }
 458         unzClose(sfxZip);
 459         return rtrnVector;
 460 }
 461
 462 std::vector<SDL_Texture*> FileIO::extractTexturesFromZip(std::string path) {
 463         unzFile textureZip = unzOpen(path.c_str());
 464         unz_global_info ugi;
 465         unzGetGlobalInfo(textureZip, &ugi);
 466
 467         std::vector<SDL_Texture*> rtrnVect(ugi.number_entry);
 468
 469         uLong i;
 470         std::cout << "Extracting" << "\n";
 471         for (i = 0; i < ugi.number_entry; i++) {
 472                 unz_file_info ufi;
 473                 char filename[256];
 474                 unzGetCurrentFileInfo(textureZip, &ufi, filename, sizeof(filename), NULL, 0, NULL, 0);
 475
 476                 uInt size_buf = ufi.uncompressed_size;
 477                 //std::cout << size_buf << "\n";
 478                 void* buf = (void*)malloc(size_buf);
 479                 int err = unzOpenCurrentFilePassword(textureZip, password);
 480                 if (err != UNZ_OK)
 481                 {
 482                         printf("errPass\n");
 483                         int err = unzOpenCurrentFilePassword(textureZip, "test");
 484                 }
 485
 486                 err = unzReadCurrentFile(textureZip, buf, size_buf);
 487                 if (err < 0) {
 488                         std::cout << "errunzTxt\n";
 489                 }
 490                 SDL_RWops* rw = SDL_RWFromMem(buf, size_buf);
 491                 if (rw == NULL) {
 492                         std::cout << "RW\n";
 493                 }
 494                 SDL_Surface* surf = IMG_Load_RW(rw, 1);
 495                 if (surf == NULL) {
 496                         std::cout << "surf\n";
 497                 }
 498                 SDL_Texture* text = SDL_CreateTextureFromSurface(rsc->rendPtr, surf);
 499                 if (text == NULL) {
 500                         std::cout << "text\n";
 501                 }
 502
 503                 std::string name = getZipFileName(ufi, textureZip);
 504
 505                 char chars[] = "()-.png";
 506
 507                 for (unsigned int i = 0; i < strlen(chars); ++i)
 508                 {
 509                         // you need include <algorithm> to use general algorithms like std::remove()
 510                         name.erase(std::remove(name.begin(), name.end(), chars[i]), name.end());
 511                 }
 512                 int index = stoi(name) - 1;
 513
 514                 std::cout << index << "\n";
 515
 516                 rtrnVect.at(index) = text;
 517
 518                 SDL_FreeSurface(surf);
 519                 free(buf);
 520
 521                 unzGoToNextFile(textureZip);
 522         }
 523         unzClose(textureZip);
 524         return rtrnVect;
 525 }
 526
 527 char* FileIO::getZipFileName(unz_file_info ufi, unzFile uf) {
 528         char *fileName = (char *)malloc(ufi.size_filename + 1);
 529         unzGetCurrentFileInfo(uf, &ufi, fileName, ufi.size_filename + 1, NULL, 0, NULL, 0);
 530         fileName[ufi.size_filename] = '\0';
 531         return fileName;
 532 }
 533
 534 void FileIO::eraseUserData()
 535 {
 536                 saveUserData(1, LevelUnlocks);
 537                 saveUserData(0, LevelScores);
 538                 saveUserData(0, GameSettings);
 539         for (int line = 1; line <= 4; line++) {
 540                 std::cout << "skipyyy";
 541                 saveScoreData(arcade, 0, line);
 542                 saveScoreData(life, 0, line);
 543         }
 544 }
 545
 546 std::vector<int> FileIO::splitInt(std::string str, char delimiter) {
 547         std::vector<int> internal;
 548         std::stringstream ss(str);
 549         std::string result;
 550
 551         while (std::getline(ss, result, delimiter)) {
 552                 int i = atoi(result.c_str());
 553                 internal.push_back(i);
 554         }
 555         return internal;
 556 }
 557 std::vector<std::string> FileIO::split(std::string str, char delimiter) {
 558         std::vector<std::string> internal;
 559         std::stringstream ss(str);
 560         std::string result;
 561
 562         while (std::getline(ss, result, delimiter)) {
 563                 internal.push_back(result);
 564         }
 565         return internal;
 566 }